from django.shortcuts import render
from django.shortcuts import HttpResponse
from django.views import View
from idna.idnadata import joining_types
from rest_framework.permissions import AllowAny
import re
from django.utils import timezone
from datetime import datetime
from app01 import models
import psutil
import json
import os
from django.http import JsonResponse

permission_classes = [AllowAny]
# 配置日志__name__指当前目录
import logging

logger = logging.getLogger(__name__)


def spider(request):
    # 1.根据request读取用户请求数据
    # 2.根据models(orm)操作数据库
    name_list = ["联通", "移动", "电信"]

    # 显示到浏览器

    # data_string = ",".join(name_list)
    # return HttpResponse("error")
    return render(request, template_name="spider.html", context={"n1": "完成01", "n2": name_list})


def demo(request):
    # 对数据库表的增删改查
    # 1.新增
    # models.Depart.objects.create(title="销售")
    # models.Depart.objects.create(title="运营")
    # models.UserInfo.objects.create(name="罗洋",age=30,email="xxx@example.com")
    # models.UserInfo.objects.create(name="张三",age=10,email="xxx@example.com")

    # 2. 删除 (其中filter是查找的意思)
    # models.Depart.objects.filter(id=2).delete()
    # models.Depart.objects.filter(name="销售").delete()
    # models.Depart.objects.filter(id=1,name="销售").delete()
    # 3.修改
    # models.UserInfo.objects.filter(id=1).update(name='李四',age=312)
    # models.UserInfo.objects.all().update(name='李四',age=112)
    # 4.查询
    # v1 = models.UserInfo.objects.all()
    # v2 = models.UserInfo.objects.filter(id = 1)
    # v2 = models.UserInfo.objects.filter(id__gt = 1)#id>1
    # v2 = models.UserInfo.objects.filter(id__gte = 1)#id>=1
    # v2 = models.UserInfo.objects.filter(id__lt = 1)#id<1
    # v2 = models.UserInfo.objects.filter(id__lte = 1)#id<=1
    # 特殊列表=[第一行数据,第二行数据,第三行数据]
    # queueset = models.UserInfo.objects.filter(id__gt=1)
    queueset = models.UserInfo.objects.all()
    print("--------------------------------")
    print(queueset[0].id)
    for row in queueset:
        print(row.id, row.name, row.age, row.email)
    return HttpResponse("ok")


def user(request):
    if request.method == "GET":
        # 如果请求方法是 GET
        queryset = models.UserInfo.objects.all()
        # 获取 UserInfo 模型的所有对象，存储在 queryset 中
        # return render(request, template_name='user.html')
        return render(request, template_name='user.html', context={"queryset": queryset})
        # 使用 render 函数渲染 user.html 模板，并将 queryset 作为上下文传递给模板
    elif request.method == "POST":
        # 如果请求方法是 POST
        username = request.POST.get("user")
        # 从 POST 请求的数据中获取名为 "user" 的参数
        age = request.POST.get("age")
        # 从 POST 请求的数据中获取名为 "age" 的参数
        email = request.POST.get("email")
        # 从 POST 请求的数据中获取名为 "email" 的参数
        models.UserInfo.objects.create(name=username, age=age, email=email)
        # 使用获取的数据创建一个新的 UserInfo 对象，并保存到数据库中
        queryset = models.UserInfo.objects.all()
        # 获取更新后的 UserInfo 模型的所有对象，存储在 queryset 中
        return render(request, template_name='user.html', context={"queryset": queryset})
        # 使用 render 函数渲染 user.html 模板，并将更新后的 queryset 作为上下文传递给模板
    else:
        # 如果请求方法既不是 GET 也不是 POST
        return HttpResponse("method error")
        # 返回一个包含 "method error" 文本的 HttpResponse 对象，表示不支持该请求方法


def convert_bytes(bytes_value):
    # 定义单位列表
    units = ['B', 'KB', 'MB', 'GB', 'TB']
    unit_index = 0
    while bytes_value >= 1024 and unit_index < len(units) - 1:
        bytes_value /= 1024
        unit_index += 1
    # 保留两位小数
    return f"{round(bytes_value, 2)}{units[unit_index]}"


def get_system_status(request):
    system_status = {}
    pid = os.getpid()  # 获取当前 Django 进程的进程 ID
    try:
        process = psutil.Process(pid)  # 通过进程 ID 获取进程对象

        # 获取进程启动时间
        start_time_timestamp = process.create_time()
        start_time = datetime.fromtimestamp(start_time_timestamp)
        system_status['start_time'] = start_time.strftime('%Y-%m-%d %H:%M:%S')

        # 计算已经运行的时间
        current_time = datetime.now()
        elapsed_time = current_time - start_time
        elapsed_seconds = elapsed_time.total_seconds()
        hours, remainder = divmod(elapsed_seconds, 3600)
        minutes, seconds = divmod(remainder, 60)
        system_status['elapsed_time'] = f'{int(hours)} 小时 {int(minutes)} 分钟 {int(seconds)} 秒'

        # 获取该进程的 CPU 使用率
        cpu_percent = process.cpu_percent(interval=1)
        system_status['cpu'] = f"{cpu_percent}%"
    except psutil.AccessDenied:
        system_status['cpu_error'] = '权限不足，无法获取 CPU 使用率。'
    except psutil.TimeoutExpired:
        system_status['cpu_error'] = '获取 CPU 使用率超时。'
    except Exception as e:
        system_status['cpu_error'] = '获取 CPU 使用率时出错: ' + str(e)

    try:
        # 获取该进程的内存信息
        memory = process.memory_info()
        system_status['memory'] = {
            'rss': convert_bytes(memory.rss),
            'vms': convert_bytes(memory.vms),
            'percent': f"{round(process.memory_percent(), 2)}%"  # 保留两位小数
        }
    except psutil.AccessDenied:
        system_status['memory_error'] = '权限不足，无法获取内存信息。'
    except psutil.TimeoutExpired:
        system_status['memory_error'] = '获取内存信息超时。'
    except Exception as e:
        system_status['memory_error'] = '获取内存信息时出错: ' + str(e)

    try:
        # 获取磁盘使用信息
        disk_usage = psutil.disk_usage('/')
        system_status['disk'] = {
            'total': convert_bytes(disk_usage.total),
            'used': convert_bytes(disk_usage.used),
            'free': convert_bytes(disk_usage.free),
            'percent': f"{disk_usage.percent}%"
        }

        # 获取磁盘 I/O 信息
        disk_io_counters = psutil.disk_io_counters()
        system_status['disk_io'] = {
            'read_count': disk_io_counters.read_count,
            'write_count': disk_io_counters.write_count,
            'read_bytes': convert_bytes(disk_io_counters.read_bytes),
            'write_bytes': convert_bytes(disk_io_counters.write_bytes)
        }
    except Exception as e:
        system_status['disk_error'] = f'获取磁盘信息时出错: {str(e)}'

    try:
        # 获取网络连接数
        connections = psutil.net_connections()
        system_status['network_connections'] = len(connections)

        # 获取网络 I/O 信息
        net_io_counters = psutil.net_io_counters()
        system_status['network_io'] = {
            'bytes_sent': convert_bytes(net_io_counters.bytes_sent),
            'bytes_recv': convert_bytes(net_io_counters.bytes_recv)
        }
    except Exception as e:
        system_status['network_error'] = f'获取网络信息时出错: {str(e)}'

    return JsonResponse(system_status, json_dumps_params={'ensure_ascii': False})


def index(request):
    if request.method == "GET":
        # 如果请求方法是 GET
        return render(request, template_name='index.html')
        # 使用 render 函数渲染 user.html 模板，并将 queryset 作为上下文传递给模板


def post2(request):
    if request.method == "GET":
        # 如果请求方法是 GET
        return render(request, template_name='post2.html')
        # 使用 render 函数渲染 user.html 模板，并将 queryset 作为上下文传递给模板


def test(request):
    if request.method == "GET":
        # 如果请求方法是 GET
        return render(request, template_name='index.html')
        # 使用 render 函数渲染 user.html 模板，并将 queryset 作为上下文传递给模板


# 用于对xunlei数据进行解析，解构出主数据
def extract_magnet_links(long_string):
    my_dict_list = []
    # 定义正则表达式模式，用于匹配磁力链接
    pattern = r'(magnet:\?[^ \n]+)'
    # 使用 finditer 方法查找所有匹配的磁力链接
    matches = list(re.finditer(pattern, long_string))
    # 遍历所有匹配结果
    for i, match in enumerate(matches):
        main_link = match.group(0)
        # 处理第一个磁力链接的 front 部分
        if i == 0:
            front = long_string[:match.start()].strip()
        else:
            # 非第一个磁力链接，其 front 为上一个链接到当前链接之间的文本
            front = long_string[matches[i - 1].end():match.start()].strip()

        # 处理最后一个磁力链接的 back 部分
        if i == len(matches) - 1:
            back = long_string[match.end():].strip()
        else:
            # 非最后一个磁力链接，其 back 为当前链接到下一个链接之间的文本
            back = long_string[match.end():matches[i + 1].start()].strip()

        result_dict = {
            "front": front,
            "main_link": main_link,
            "back": back
        }
        # 将包含前后文本和链接的字典添加到结果列表中
        my_dict_list.append(result_dict)

    return my_dict_list


class XunleiListView(View):
    def get(self, request):
        # 查询 XunleiListModels 模型的所有对象
        queryset = models.XunleiListModels.objects.all()
        # 将查询集转换为字典列表
        data = list(queryset.values())
        print(data)
        # 返回 JSON 响应
        return JsonResponse(data, safe=False)

    def post(self, request):
        try:
            # 尝试将请求体解码为字符串并解析为 JSON 数据
            data = json.loads(request.body.decode("utf-8"))
            # 检查数据是否为字典类型且包含 "data" 字段
            if isinstance(data, dict) and "data" in data:
                # 可以在这里添加对 "data" 字段值的更多限制条件，比如长度、格式等
                input_data = data["data"]
                # print(f"提取的输入数据----------: {input_data}")
                # 返回包含成功状态码和解析后数据的 JSON 响应
                result = extract_magnet_links(input_data)

                main_link_init_return = ''
                for item in result:
                    current_time = datetime.now()
                    timestamp = current_time.timestamp()
                    # print("本地当前时间的:", current_time, "时间戳:", timestamp)
                    models.XunleiListModels.objects.create(front_name=item['front'], main_link=item['main_link'],
                                                           back_name=item['back'], time_join=timestamp)
                    main_link_init_return += item['main_link'] + '\n'
                    # models.UserInfo.objects.create(name="张三",age=10,email="xxx@example.com")
                # 日志的用法
                logger.info(result)
                print(result)
                # print("--------------------------------")
                return JsonResponse({'code': 200, 'info': '数据接收成功', 'message': main_link_init_return},
                                    json_dumps_params={'indent': 4})
            else:
                # 若数据格式不符合要求，返回错误信息和状态码 400
                return JsonResponse({'code': 400, 'message': '请求数据格式不符合要求，必须包含 "data" 字段'}, status=400)
        except json.JSONDecodeError:
            # 若解析失败，返回错误信息和状态码 400
            return JsonResponse({'code': 400, 'message': '请求体不是有效的 JSON 格式'}, status=400)

    def other_method(self, request):
        return HttpResponse("method error")

    def dispatch(self, request, *args, **kwargs):
        if request.method == 'GET':
            return self.get(request, *args, **kwargs)
        elif request.method == 'POST':
            return self.post(request, *args, **kwargs)
        else:
            return self.other_method(request, *args, **kwargs)
